# mp4_cut.py：视频素材剪辑
#
# 1. 查看字幕过程中，在线标记要剪辑的地方，1个~是只剪这一个(暂时只实现这个) ，2个~是开始，3个~是结束  位于文字上，时间位于文字上方
# 2. 手动执行脚本进行指定路径下的文件转换，为doc并命名（从1开始）保存到固定位置/云盘 两个参数： 读出和写入的路径
# -3. 下拉脚本文件，自动比对原字幕文件，找到要剪辑的位置进行视频剪辑命名和保存 三个参数：云盘搜索关键字，原字幕和视频路径
# 3. 上一步修改为不自动更新srt，而是手动下载到待剪区，只传入待剪区、原视频路径即可；和根据待剪区的图片进行剪辑差不多，前者传文件夹，后者传文件
# 4. 视频去水印和后期处理（画质优化，重命名，封面截取，加片头片尾等），一个参数：单个视频或视频文件夹路径和名字
# 4. 尝试根据打击节奏识别出特定画面
# 5. 将N秒一张的截图放到自动创建的指定路径

# 待实现：
# srt转doc
# 查找变动srt
# 识别剪辑的时间戳字符
# 进行剪辑
# -将最新修改的文件排序后，下载此页，依次比较这个文件和同步区的此文件的hash值是否变化
# -变化了认为是修改了，保留此文件，否则删除，继续下一个文件比较
# -判断完毕后将修改后的文件全部替换同步区文件，删除后缀后移动到原路径
# 在指定待剪区根据图片名称去指定路径修改指定文件，按照图片上的时间
# 上一步操作传入待剪区路径上一级（多图片路径上级）、mp4文件路径   原则一次剪一个文件
# 在待剪区找不到粗剪两个字 默认不进行 找到后自动计算要剪的图片前后秒数，根据相邻文件名字
# 剪辑成片仍放到此粗剪路径下  命名是pic名字

# 根据srt剪，原则是一次剪多个文件，传入待剪区路径上一级（多字幕路径上级）、mp4文件夹路径
# 其它同上面，输出命名是集数加srt词条

# 需要修改的全局变量或配置：
# 关闭网盘自动更新和桌面通知
# 配置夸克云盘的同步区路径和下拉临时区路径
# 视频素材成片路径
# 字幕上一级文件夹要合适且准确
# pip install python-docx
# pic和srt的路径关键词不能修改 也是同步路径


import smtplib
import sys
import io

import docx

import eyed3
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.application import MIMEApplication
from pydub import AudioSegment
import email
import imaplib
import os
import shutil
import time
import traceback
import zipfile
from email.header import decode_header, Header
from email.utils import parseaddr
from pathlib import Path
import datetime
import pyautogui
import pyperclip
from moviepy.editor import VideoFileClip
import hashlib
from moviepy.editor import *


DEBUG = 1
PC_COM = 1  # 0-家庭 1-公司
PIC_KEY = "pic_temp"
SRT_KEY = "srt_temp"

remote_server_url = 'imap.qq.com'
email_url = "3324564761@qq.com"  # 当前使用邮箱
password = "ioaeproulegrchff"
email_msg_to = "1984832368@qq.com"  # 发送邮箱
check_time = 10 # n 秒检测一次是否更新

srt_check_path = "D:\\video\\video_temp\\海绵宝宝系列\\第2季"  # 字幕文件检索路径
pic_syn_path = "D:\\video\\pic_temp"  # 图片文件同步路径
srt_syn_path = "D:\\video\\srt_temp"  # 字幕文件云盘同步路径 不可删除 否则云盘要重新配置
check_hash_path = "D:\\video\\check_hash_temp"  # 下拉后需要比对hash的文件路径 用后即删
quark_exe_path = '"D:\\Program Files\\quark-cloud-drive\\QuarkCloudDrive.exe"'  # 夸克云盘路径

rewrite_print = print
def print(*arg):
   rewrite_print(*arg)
   output_dir = "log_file"
   if not os.path.exists(output_dir):
         os.makedirs(output_dir)
   log_name = 'log.txt' # 日志文件名称
   filename = os.path.join(output_dir, log_name)
   rewrite_print(*arg,file=open(filename,"a")) # 写入文件

def print_d(*arg): #仿真调试用
    if DEBUG == 1:
        print('------调试打印开始-----')
        print(*arg)
        print('------调试打印结束-----\r\n')

class py_gui:
    def __init__(self):  # 不同电脑的gui坐标值不一样
        pyautogui.PAUSE = 0.5 # 所有操作暂停0.5s

        self.dpi_x = pyautogui.size()[0]  # 长 默认2240
        self.dpi_y = pyautogui.size()[1]  # 高 默认1400

        self.x_radio = self.dpi_x/2240  # 自动进行坐标换算
        self.y_radio = self.dpi_y/1400


    def click(time_s = None):
        if time_s != None:
            time.sleep(time_s)
        pyautogui.click()

    def doubleClick(time_s = None):
        if time_s != None:
            time.sleep(time_s)
        pyautogui.doubleClick()

    def move_click(self, x, y, time_s = None):  # 鼠标移动到位置延时点击
        x = int((x) * (self.x_radio))
        y = int((y) * (self.y_radio))
        print(x, y)

        pyautogui.moveTo(x, y)
        py_gui.click(time_s)

    def dragTo(self, x, y):  # 默认左键拖拽
        x = int((x) * (self.x_radio))
        y = int((y) * (self.y_radio))

        pyautogui.dragTo(x, y, 1, button="left")

    def check_completed(self, x, y, r=None, g=None, b=None): # 判断是否完成某项内容 检测某个点的rgb值，如果rgb变化了认为有动作  或者如果符合rgb的值认为成功
        # 一直等待生成完成 判断x y 的rgb是不是r g b （识别中） 不考虑识别失败情况
        x = int((x) * (self.x_radio))
        y = int((y) * (self.y_radio))

        pyautogui.moveTo(x, y, 1)
        rgb = pyautogui.screenshot().getpixel((x, y))
        r_last = rgb[0]
        g_last = rgb[1]
        b_last = rgb[2]
        time.sleep(3)

        if r == None or g == None or b == None: # 有一点像素变化认为完成
            while rgb[0] == r_last and rgb[1] == g_last and rgb[2] == b_last:  # 没有颜色变化
                rgb = pyautogui.screenshot().getpixel((x, y))
                posi = 'x:' + str(x).rjust(4) + ' y:' + str(y).rjust(4) + '  RGB:' + str(rgb)
                print("等待···", posi)
                time.sleep(1)
            print("发现颜色变化")
        else: # 符合rgb认为完成
            while rgb[0] != r and rgb[1] != g and rgb[2] != b:  # 没有出现符合的颜色
                rgb = pyautogui.screenshot().getpixel((x, y))
                posi = 'x:' + str(x).rjust(4) + ' y:' + str(y).rjust(4) + '  RGB:' + str(rgb)
                print("等待···", posi)
                time.sleep(1)
            print("发现符合的颜色")

class doc_function():  # 文件操作
    def save_data_txt(data):  # 添加数据到文件
        info_str = str(data)
        info_str += '\r\n'
        print(info_str)
        with open('flash_tool.log', 'a') as lead:
            lead.write(info_str)

    def set_data(data):  # 重写文件
        data_w = "data  " + data
        fi = open('data.txt', 'w', encoding='utf-8')
        fi.write(data_w)

    def mkdir(path):  # 新建文件夹
        folder = os.path.exists(path)

        if not folder:  # 判断是否存在文件夹如果不存在则创建为文件夹
            os.makedirs(path)  # makedirs 创建文件时如果路径不存在会创建这个路径
            print("---  creat new folder...  ---")
        else:
            print("new folder is:", path)

    def copyfile_no_dele(srcfile, dstpath):  # 复制文件 如果目标路径存在同名文件则不复制
        if not os.path.isfile(srcfile):
            print("%s not exist!" % (srcfile))
        else:
            fpath, fname = os.path.split(srcfile)  # 分离文件名和路径
            sample_name = srt_syn_path + "\\" + fname
            if os.path.exists(sample_name) == False:
                shutil.copy(srcfile, dstpath)  # 复制文件
            else:
                print("\r\n不进行复制，已经存在文件", sample_name)

    def copyfile_dele(srcfile, dstpath):  # 复制文件 如果目标路径存在同名文件则删除源文件
        if not os.path.isfile(srcfile):
            print("%s not exist!" % (srcfile))
        else:
            fpath, fname = os.path.split(srcfile)  # 分离文件名和路径
            sample_name = srt_syn_path + "\\" + fname
            if os.path.exists(sample_name) == False: # 不存在同名文件
                shutil.copy(srcfile, dstpath)  # 复制文件
            else:
                os.remove(sample_name) # 删除源文件
                shutil.copy(srcfile, dstpath)  # 复制文件

    def file_zip(start_file, zip_dir):  # 压缩文件
        # start_dir 要压缩的文件
        # zip_file 输出zip文件的路径
        fpath_start_dir, fname = os.path.split(start_file)  # 分离文件名和路径

        zip_file = zip_dir + '.zip'
        z = zipfile.ZipFile(zip_file, 'w', zipfile.ZIP_DEFLATED)
        print(z)
        for path, dirname, file_name in os.walk(fpath_start_dir):
            # print("文件夹根路径：", path)
            fpath = path.replace(fpath_start_dir, '')  # 去除根路径名称
            # print("--去除根路径：", fpath)
            fpath = fpath and fpath + os.sep  # 在原fpath加上\
            # print("****去除根路径+\ ：", fpath)

            for filename in file_name:  # 逐个循环读取文档名称
                if filename.find(fname) >= 0:
                    # print(filename)
                    z.write(os.path.join(path, filename), fpath + filename)  # 实现在输出路径的Zip压缩操作
        z.close()


    def file_unzip_download(unzip_file):
        print(f"开始进行解压缩并下载···")

        zip_file = zipfile.ZipFile(unzip_file)
        fpath, fname = os.path.split(unzip_file)
        out_file = fpath + "\\unzip"
        if os.path.isdir(out_file):
            shutil.rmtree(out_file)
            os.mkdir(out_file)
        else:
            os.mkdir(out_file)
        for names in zip_file.namelist():
            zip_file.extract(names, out_file)
        zip_file.close()
        folder = Path(out_file.strip())
        result = list(folder.rglob(f'*{".hex"}*'))  # 只要hex文件
        print(result[0])  # 默认一个压缩包只有一个文件
        flash_file = str(result[0])
        # 进行文件的各种操作处理
        shutil.rmtree(out_file)

    def search_file(key_word, self_path=None):  # 查找的关键字 self_path是自定义路径
        if self_path != None:
            folder_str = self_path
        else:
            folder_str = os.path.join(os.getcwd(), qq_email_rx.Subject)  # 刘森 新世界

        folder = Path(folder_str.strip())
        print(folder)
        if folder.exists():
            print("开始根据关键字查找文件···")
        else:
            print("未找到存放关键字对应文件的文件夹")
            return None

        result = list(folder.rglob(f'*{key_word}*'))
        if not result:
            print(f'在{folder} 下未找到关键字名称 {key_word} 的文件夹或文件')
            return None
        else:
            print(f'在{folder} 下找到关键字名称 {key_word} 的文件夹或文件{result}')
            return result

    def get_str_row_column(words): #获取字符串中行数和列的最大字符数，返回两者的最大值
        row = words.count("\n") + 1

        # 存储所有的相同字符之间的距离
        length = []
        loc = 0
        last_loc = 0

        while words.find("\n", loc+1) != -1:
            loc = words.find("\n", loc+1)

            length.append(loc - last_loc)
            last_loc = loc

        length.append(len(words) - last_loc) # 获取最后一行长度
        # print(length)
        # print(f'最大长度：{max(length)}')
        column = max(length)
        # print(max(row, column))
        return max(row, column)

    def delete_files(file_path):
        if os.path.exists(file_path):
            shutil.rmtree(file_path)
            return True
        else:
            # file not found message
            print(f'要删除的文件夹{file_path}找不到')
            return False

    def diff_delete_file(path1, path2): # 对比两个文件夹，删除path1中多余文件
        fileName1 = set([_ for _ in os.listdir(path1)])
        fileName2 = set([_ for _ in os.listdir(path2)])
        # print_d(path1, fileName1, path2, fileName2)
        diffs = fileName1.difference(fileName2)  # fileName1对比fileName2，fileName1中多出来的文件；注意，如果fileName2里有fileName1中没有的文件，也不会筛选出来
        filePath = [os.path.join(path1, i) for i in diffs]
        for file in filePath:
            os.remove(file)
        print("删除的文件有：", filePath)

    def hash(file_path, Bytes=1024):  # 计算文件hash
        md5_value = hashlib.md5()  # 创建一个md5算法对象
        with open(file_path, 'rb') as f:  # 打开一个文件，必须是'rb'模式打开
            while 1:
                data = f.read(Bytes)  # 由于是一个文件，每次只读取固定字节
                if data:  # 当读取内容不为空时对读取内容进行update
                    md5_value.update(data)
                else:  # 当整个文件读完之后停止update
                    break
        ret = md5_value.hexdigest()  # 获取这个文件的MD5值
        return ret

    def read_docx(docName):  # 返回以文字为key 开始时间 结束时间为元素的字典值
        document = open(docName, encoding='utf-8-sig', errors='ignore')
        file = document.read()
        doc_data_list = file.splitlines()
        time_stamp = dict()
        last_data = ""
        for data in doc_data_list:
            if data.count('~') == 1:  # 只要这一行
                start_end = []
                start_end.append(last_data[3:8])
                start_end.append(last_data[20:25])
                time_stamp[str(data)] = start_end

            last_data = data

        print(time_stamp)
        return time_stamp


        # 在字符串中查找~的位置，向上箭头 箭头两边是时间
        # print("段落数:" + str(len(file.paragraphs)))  # 段落数为13，每个回车隔离一段
        #
        # # 输出每一段的内容
        # for para in file.paragraphs:
        #     print(para.text)
        #
        # # 输出段落编号及段落内容
        # for i in range(len(file.paragraphs)):
        #     print("第" + str(i) + "段的内容是：" + file.paragraphs[i].text)


    def srt_doc(srt_path, doc_path):  # srt文件转换为doc文件
        check_file = ".srt"
        file_list = doc_function.search_file(check_file, srt_path)
        if file_list[0] == None:  # 未找到一个srt文件
            print(f'在{srt_path}路径下未找到srt文件，请确认查找路径是否正确')
        else:
            # 将所有srt文件复制到 doc_path 同步路径下面
            srt_no_syn = ""
            doc_function.mkdir(doc_path)  # 创建文件夹
            for srt_file in file_list:
                doc_function.copyfile_no_dele(srt_file, doc_path)  # 将srt复制到对应子文件夹
                # 将文件名字后缀改为doc
                fpath, fname = os.path.split(srt_file)
                syn_file = doc_path + "\\" + fname
                portion = os.path.splitext(syn_file)
                newname = portion[0] + ".doc"
                try:
                    os.rename(syn_file, newname)
                    srt_no_syn = "\r\n" + srt_no_syn + fpath + "\\" + fname + "\r\n"
                except:
                    print("文件已存在")
                    os.remove(syn_file)
                    continue

            if srt_no_syn == "":
                print(f'在{srt_path}路径下未找到未同步的srt文件，之前已全部同步')
            else:
                print(f'在{srt_path}路径下找到未同步的srt文件：{srt_no_syn}， 并进行同步成功')

    def kuake_download(key_word, download_path = check_hash_path):  # 夸克云盘下载
        # 网盘初始化
        pyautogui.hotkey('win', 'd')  # 先清空屏幕
        os.startfile(quark_exe_path)  # 将软件放到桌面上
        time.sleep(1)
        pyautogui.hotkey('alt', ' ', 'X')  # 将文件窗口最大化
        time.sleep(1)
        pyautogui.hotkey('alt', ' ', 'X')  # 将文件窗口最大化
        doc_function.mkdir(check_hash_path)  # 创建用于比对hash的文件夹 也是下拉内容临时存放区

        # 进行一页网盘文档数据的下载
        gui.move_click(62, 62, 0.1)  # 点击首页
        gui.move_click(1510, 48, 0.1)  # 点击搜索框
        pyperclip.copy(key_word)  # 输入查找文件/文件夹
        pyautogui.hotkey('ctrl', 'v')
        gui.check_completed(449, 205, 158, 197, 255)  # 等待检索完成
        gui.move_click(449, 205, 0.1)  # 点击文件夹
        gui.check_completed(485, 295, 221, 221, 221)  # 等待刷新
        gui.move_click(406, 353, 0.1)  # 点击全选
        gui.move_click(1695, 123, 0.1)  # 点击下载
        time.sleep(1)
        pyautogui.hotkey('alt', ' ', 'X')  # 将文件窗口最大化
        gui.move_click(1674, 74, 0.1)  # 点击输出框
        pyperclip.copy(check_hash_path)  # 输入下载路径
        pyautogui.hotkey('ctrl', 'v')
        pyautogui.press('enter')
        gui.move_click(1955, 1296, 0.1)  # 点击选择文件夹

        # 等待下载完成
        gui.move_click(62, 270, 1)  # 点击传输
        gui.move_click(225, 198, 1)  # 点击下载
        gui.move_click(429, 135, 1)  # 点击正在下载
        gui.check_completed(420, 303, 255, 255, 255)  # 判断是否下载完
        time.sleep(0.2)
        gui.check_completed(420, 303, 255, 255, 255)  # 判断是否下载完 多次确认

    def diff_file_check(old_folder=None, new_folder=check_hash_path):  # 变动文件查找，返回hash值变化的文件
        doc_function.diff_delete_file(new_folder, old_folder)  # 删除多余文件
        # 文件对比
        srt_syn = ""
        new_file_list = []
        files = os.listdir(new_folder)
        for file in files:  # 进行文件的比对 通过hash值
            new_file_path = new_folder + "\\" + file
            hash_new = doc_function.hash(new_file_path)
            old_file_path = old_folder + "\\" + file
            hash_old = doc_function.hash(old_file_path)
            if hash_new != hash_old:  # 文件变化
                srt_syn = "\r\n" + srt_syn + old_file_path + "\r\n"
                print("文件发生改动：", new_file_path)
                # doc_function.copyfile_dele(new_file_path, old_folder)  # 复制新文件到老路径下面 后期要加
                new_file_list.append(new_file_path)

        return new_file_list

    def mp4_cut_by_srt(mp4_path, srt_name_list):  # mp4_path :文件路径  srt_name_list：要修改的文件名字和时间戳所在文件
        # print(mp4_path, srt_name_list)
        path = mp4_path  # 待读取的文件夹
        path_list = os.listdir(mp4_path)
        path_list.sort()  # 对读取的路径进行排序
        mp4_list = []
        for filename in path_list:
            mp4_list.append(os.path.join(path, filename))

        for srt_name in srt_name_list:
            fpath, fname = os.path.split(srt_name)
            fname = fname[:-4]  # 去掉后缀
            if fname.isdigit() == True:  # 判断是否是数字，不是报错，是进行mp4文件名字对应
                index = int(fname) - 1  # 索引是名字-1  从0开始
                mp4_name = mp4_list[index]
                doc_function.mp4_cut(srt_name, mp4_name)
            else:
                print(f'{srt_name}名字不是数字，必需是纯数字格式，便须查找对应mp4！！！')

        # doc_function.delete_files(check_hash_path)  # 将临时文件夹删除

    def mp4_cut(srt, mp4):  # 根据srt文件对mp4进行剪切 剪切识别符见简介或readme
        print(f'开始根据{srt}  对  {mp4}进行剪切')
        time_stamp = doc_function.read_docx(str(srt))

        # print(time_stamp)
        # 以上一级路径为名字创建excel，以集数为列名进行添加 内容 新行  保存路径为上一级路径

    def video_images(mp4_files_list, image_speed_time): # 将视频按几秒一帧输出为图片 mp4_files_list 文件夹或文件路径  speed_time_image: 几秒出1张
        image_speed = 1 / image_speed_time
        if os.path.isdir(mp4_files_list):  # 文件夹
            mp4_names = os.listdir(mp4_files_list)
            # 在pic_syn_path中以mp4_files_list最后文件夹创建文件夹
            pic_top_path = pic_syn_path + "\\" + mp4_files_list.split('\\')[-1] + "pic"
            doc_function.mkdir(pic_top_path)

        elif os.path.isfile(mp4_files_list):  # 文件
            mp4_names = []
            mp4_names.append(mp4_files_list.split('\\')[-1])
            # 在pic_syn_path中以mp4_files_list最后文件名创建文件夹
            pic_top_path = pic_syn_path
            # print(mp4_names, pic_top_path, image_speed_time)

        for mp4 in mp4_names:
            mp4_path = mp4_files_list + "\\" + mp4
            if os.path.isfile(mp4_files_list):  # 文件
                mp4_path = mp4_files_list
            # print(mp4_path)
            pic_bottom_path = pic_top_path + "\\" + mp4[:-4]  # 第几集
            if not os.path.exists(pic_bottom_path):  # 如果不存在文件夹就新建，并存放图片
                doc_function.mkdir(pic_bottom_path)
                clipV = VideoFileClip(mp4_path)
                # 在此文件夹存放截图
                jpg_name = pic_bottom_path + "\\%03d.jpg"
                clipV.write_images_sequence(jpg_name, image_speed)  # 视频输出成图片，0.5表示2秒输出一张图片
                # 将文件以上两级路径+时间重命名
                pics_path_bottom_names = os.listdir(pic_bottom_path)
                pic_top_name = mp4_files_list.split('\\')[-1]
                for pic in pics_path_bottom_names:
                    seconds = int(pic[:-4]) * image_speed_time
                    m, s = divmod(seconds, 60)
                    h, m = divmod(m, 60)
                    date_str = str(h) + "." + str(m) + "." + str(s)
                    old_name = pic_bottom_path + "\\" + pic
                    new_name = pic[:-4] + "_" + pic_top_name + mp4[:-4] + "_"  + date_str + ".jpg"
                    if os.path.isfile(mp4_files_list):  # 文件
                        new_name = pic[:-4] + "_" + mp4[:-4] + "_"  + date_str + ".jpg"
                    new_name = pic_bottom_path + "\\" + new_name
                    print(old_name, new_name)
                    os.rename(old_name, new_name)


            # break





if __name__ == '__main__':
    # doc_function.mp4_cut("D:\\video\\check_hash_temp\\1.doc", "D:\\video\\video_temp\\海绵宝宝系列\\海绵宝宝第15季\\第01集.mp4")



    # gui = py_gui()
    #
    # if len(sys.argv) == 2:  # 单个视频路径或视频文件夹+名字   所要处理的mp4视频的上一级路径
    #     print(f'输入的内容是：{sys.argv[1]}')
    #     if os.path.isdir(sys.argv[1]):  # 文件夹
    #         doc_function.video_images(sys.argv[1], 5)   # 后一个参数没隔这些秒截图一张
    #     elif os.path.isfile(sys.argv[1]):  # 文件
    #         print("这是个文件")

    if len(sys.argv) == 3:
        if sys.argv[1].find("D:\\") >= 0 and sys.argv[2].find("D:\\") >= 0:  # 转换srt为doc，读出和写入的文件夹路径
            if sys.argv[2].find(SRT_KEY) >= 0:  # 根据srt剪mp4
                print(f'mp4文件夹路径{sys.argv[1]}，srt粗剪文件夹路径{sys.argv[2]}')
                doc_function.mp4_cut_by_srt(sys.argv[1], sys.argv[2])
            elif sys.argv[2].find(PIC_KEY) >= 0:  # 根据pic剪mp4
                print(f'mp4文件路径{sys.argv[1]}，pic粗剪文件夹路径{sys.argv[2]}')
                doc_function.mp4_cut_by_pic(sys.argv[1], sys.argv[2])
            else:
                print(f'srt输入路径{sys.argv[1]}，doc输出文件夹路径{sys.argv[2]}')
                doc_function.srt_doc(sys.argv[1], sys.argv[2])

        elif sys.argv[1].find("D:\\") >= 0 and sys.argv[2].isdigit() == True:  # 视频截图 文件或文件夹路径 + 隔几秒一张
            print(f'截图视频的输入文件或文件夹路径{sys.argv[1]}，截图间隔时间{sys.argv[2]}')
            doc_function.video_images(sys.argv[1], int(sys.argv[2]))   # 后一个参数没隔这些秒截图一张

        else:
            print(f'请输入:\r\n'
                  f' srt输入 doc输出路径 --srt的提取和转换(路径内不能有重名路径)\r\n'
                  f' 云盘下拉关键字 原doc字幕路径 输入视频路径 --通过判断srt的变化符进行视频剪辑\r\n'
                  f' 视频路径和名字 -去水印\r\n'
                  f' 其它 -待定')

    # elif len(sys.argv) == 4:  # 云盘搜索关键字，原字幕路径（进行差异性比对）  输入视频路径
    #     if sys.argv[2].find("D:\\") >= 0 and sys.argv[3].find("D:\\") >= 0:
    #         print(f'输入的云盘下拉关键字{sys.argv[1]}，原字幕路径{sys.argv[2]}，输入视频路径{sys.argv[3]}')
    #         # doc_function.kuake_download(sys.argv[1])
    #         file_list = doc_function.diff_file_check(sys.argv[2])
    #         doc_function.mp4_cut_by_srt(sys.argv[3], file_list)
    #     else:
    #         print(f'请输入云盘下拉关键字，原字幕路径，输入视频路径')
    #
    # else:
    #     print("输入内容是：", sys.argv)
    #     print(f'请输入:\r\n'
    #           f' srt输入 doc输出路径 --srt的提取和转换(路径内不能有重名路径)\r\n'
    #           f' 云盘下拉关键字 原doc字幕路径 输入视频路径 --通过判断srt的变化符进行视频剪辑\r\n'
    #           f' 视频路径和名字 -去水印\r\n'
    #           f' 其它 -待定')

    # input()
    sys.exit(0)

    pass



